/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('dt-oc-info', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model GetOcCompetitorsRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcCompetitorsResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      competitionBrandIntroduction?: string(name='CompetitionBrandIntroduction'),
      competitionEntAddress?: string(name='CompetitionEntAddress'),
      competitionEntEsDate?: string(name='CompetitionEntEsDate', example='2007-06-08'),
      competitionEntFinTurn?: string(name='CompetitionEntFinTurn'),
      competitionEntName?: string(name='CompetitionEntName'),
      competitionIntroduction?: string(name='CompetitionIntroduction'),
      competitionLogoUrl?: string(name='CompetitionLogoUrl', example='https://pic.jingdata.com/com_logo_v3/logo_off_69997171.jpg'),
      competitionProductName?: string(name='CompetitionProductName'),
      competitionTag?: string(name='CompetitionTag'),
      competitionWebsite?: string(name='CompetitionWebsite', example='http://www.chinarsgeo.com/'),
      entName?: string(name='EntName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88b016639000336733978dc0a3'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcCompetitorsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcCompetitorsResponseBody(name='body'),
}

async function getOcCompetitorsWithOptions(request: GetOcCompetitorsRequest, runtime: Util.RuntimeOptions): GetOcCompetitorsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcCompetitors',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcCompetitors(request: GetOcCompetitorsRequest): GetOcCompetitorsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcCompetitorsWithOptions(request, runtime);
}

model GetOcCoreTeamsRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcCoreTeamsResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      memberIntroduction?: string(name='MemberIntroduction'),
      memberName?: string(name='MemberName'),
      memberPosition?: string(name='MemberPosition'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88b016639000336733978dc0a3'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcCoreTeamsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcCoreTeamsResponseBody(name='body'),
}

async function getOcCoreTeamsWithOptions(request: GetOcCoreTeamsRequest, runtime: Util.RuntimeOptions): GetOcCoreTeamsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcCoreTeams',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcCoreTeams(request: GetOcCoreTeamsRequest): GetOcCoreTeamsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcCoreTeamsWithOptions(request, runtime);
}

model GetOcFinancingRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcFinancingResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      finAmount?: string(name='FinAmount'),
      finDate?: string(name='FinDate', example='2016-10-28'),
      finTurn?: string(name='FinTurn'),
      investors?: string(name='Investors'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e849316699636879325009d7676'),
  success?: boolean(name='Success', example='true'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcFinancingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcFinancingResponseBody(name='body'),
}

async function getOcFinancingWithOptions(request: GetOcFinancingRequest, runtime: Util.RuntimeOptions): GetOcFinancingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcFinancing',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcFinancing(request: GetOcFinancingRequest): GetOcFinancingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcFinancingWithOptions(request, runtime);
}

model GetOcFuzzSearchRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcFuzzSearchResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07e116699472150851563d66ee'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='3'),
}

model GetOcFuzzSearchResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcFuzzSearchResponseBody(name='body'),
}

async function getOcFuzzSearchWithOptions(request: GetOcFuzzSearchRequest, runtime: Util.RuntimeOptions): GetOcFuzzSearchResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcFuzzSearch',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcFuzzSearch(request: GetOcFuzzSearchRequest): GetOcFuzzSearchResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcFuzzSearchWithOptions(request, runtime);
}

model GetOcIcAbnormalOperationRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcAbnormalOperationResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      inDate?: string(name='InDate', example='2017-11-02'),
      inDepartment?: string(name='InDepartment'),
      inReason?: string(name='InReason'),
      outDate?: string(name='OutDate', example='2018-08-15'),
      outDepartment?: string(name='OutDepartment'),
      outReason?: string(name='OutReason'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e842416657190876491853d9147'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='28'),
}

model GetOcIcAbnormalOperationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcAbnormalOperationResponseBody(name='body'),
}

async function getOcIcAbnormalOperationWithOptions(request: GetOcIcAbnormalOperationRequest, runtime: Util.RuntimeOptions): GetOcIcAbnormalOperationResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcAbnormalOperation',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcAbnormalOperation(request: GetOcIcAbnormalOperationRequest): GetOcIcAbnormalOperationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcAbnormalOperationWithOptions(request, runtime);
}

model GetOcIcAdminLicenseRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcAdminLicenseResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      content?: string(name='Content'),
      department?: string(name='Department'),
      endDate?: string(name='EndDate', example='2022-08-08'),
      licenseName?: string(name='LicenseName'),
      licenseNo?: string(name='LicenseNo'),
      startDate?: string(name='StartDate', example='2021-06-11'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994436747462d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='445'),
}

model GetOcIcAdminLicenseResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcAdminLicenseResponseBody(name='body'),
}

async function getOcIcAdminLicenseWithOptions(request: GetOcIcAdminLicenseRequest, runtime: Util.RuntimeOptions): GetOcIcAdminLicenseResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcAdminLicense',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcAdminLicense(request: GetOcIcAdminLicenseRequest): GetOcIcAdminLicenseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcAdminLicenseWithOptions(request, runtime);
}

model GetOcIcBasicRequest {
  searchKey?: string(name='SearchKey'),
}

model GetOcIcBasicResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: {
    checkDate?: string(name='CheckDate', example='2019-11-05'),
    entAddress?: string(name='EntAddress'),
    entBrief?: string(name='EntBrief'),
    entName?: string(name='EntName'),
    entNameEng?: string(name='EntNameEng', example='Alibaba(China)Co.,Ltd.'),
    entStatus?: string(name='EntStatus'),
    entType?: string(name='EntType'),
    esDate?: string(name='EsDate', example='2019-01-01'),
    formerNames?: string(name='FormerNames'),
    industryNameLv1?: string(name='IndustryNameLv1'),
    industryNameLv2?: string(name='IndustryNameLv2'),
    insuredNum?: string(name='InsuredNum', example='1833'),
    legalName?: string(name='LegalName'),
    licenseNumber?: string(name='LicenseNumber', example='330100400013364'),
    opFrom?: string(name='OpFrom', example='2007-03-26'),
    opScope?: string(name='OpScope'),
    opTo?: string(name='OpTo', example='2037-03-25'),
    orgNo?: string(name='OrgNo', example='FRCSZ1459'),
    recCap?: string(name='RecCap'),
    regCap?: string(name='RegCap'),
    regOrg?: string(name='RegOrg'),
    regOrgCity?: string(name='RegOrgCity'),
    regOrgDistrict?: string(name='RegOrgDistrict'),
    regOrgProvince?: string(name='RegOrgProvince'),
    socialCreditCode?: string(name='SocialCreditCode', example='91330100799655058B'),
    staffNum?: string(name='StaffNum', example='1833'),
    taxNum?: string(name='TaxNum', example='91330100799655058B'),
  }(name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f078f16659784453422252dcdbb'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcIcBasicResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcBasicResponseBody(name='body'),
}

async function getOcIcBasicWithOptions(request: GetOcIcBasicRequest, runtime: Util.RuntimeOptions): GetOcIcBasicResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcBasic',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcBasic(request: GetOcIcBasicRequest): GetOcIcBasicResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcBasicWithOptions(request, runtime);
}

model GetOcIcBranchRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcBranchResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      entStatus?: string(name='EntStatus'),
      esDate?: string(name='EsDate', example='2019-01-01'),
      operName?: string(name='OperName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994514582084d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcIcBranchResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcBranchResponseBody(name='body'),
}

async function getOcIcBranchWithOptions(request: GetOcIcBranchRequest, runtime: Util.RuntimeOptions): GetOcIcBranchResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcBranch',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcBranch(request: GetOcIcBranchRequest): GetOcIcBranchResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcBranchWithOptions(request, runtime);
}

model GetOcIcChangeRecordRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcChangeRecordResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      afterContent?: string(name='AfterContent'),
      beforeContent?: string(name='BeforeContent'),
      changeDate?: string(name='ChangeDate', example='2002-12-11'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994402826438d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='13'),
}

model GetOcIcChangeRecordResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcChangeRecordResponseBody(name='body'),
}

async function getOcIcChangeRecordWithOptions(request: GetOcIcChangeRecordRequest, runtime: Util.RuntimeOptions): GetOcIcChangeRecordResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcChangeRecord',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcChangeRecord(request: GetOcIcChangeRecordRequest): GetOcIcChangeRecordResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcChangeRecordWithOptions(request, runtime);
}

model GetOcIcCheckupRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcCheckupResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      date?: string(name='Date'),
      department?: string(name='Department'),
      result?: string(name='Result'),
      type?: string(name='Type', example='2021-05-25'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e849816684798333566155dffea'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcIcCheckupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcCheckupResponseBody(name='body'),
}

async function getOcIcCheckupWithOptions(request: GetOcIcCheckupRequest, runtime: Util.RuntimeOptions): GetOcIcCheckupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcCheckup',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcCheckup(request: GetOcIcCheckupRequest): GetOcIcCheckupResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcCheckupWithOptions(request, runtime);
}

model GetOcIcClearAccountRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcClearAccountResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      leader?: string(name='Leader'),
      member?: string(name='Member'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcIcClearAccountResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcClearAccountResponseBody(name='body'),
}

async function getOcIcClearAccountWithOptions(request: GetOcIcClearAccountRequest, runtime: Util.RuntimeOptions): GetOcIcClearAccountResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcClearAccount',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcClearAccount(request: GetOcIcClearAccountRequest): GetOcIcClearAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcClearAccountWithOptions(request, runtime);
}

model GetOcIcDoubleCheckupRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcDoubleCheckupResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      inspectDate?: string(name='InspectDate', example='2021-05-27'),
      inspectDepartment?: string(name='InspectDepartment'),
      inspectItem?: string(name='InspectItem'),
      inspectPlanId?: string(name='InspectPlanId', example='32081320211032'),
      inspectPlanName?: string(name='InspectPlanName'),
      inspectResult?: string(name='InspectResult'),
      inspectTaskId?: string(name='InspectTaskId', example='320813202104271001'),
      inspectTaskName?: string(name='InspectTaskName'),
      inspectTypeName?: string(name='InspectTypeName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88a516684802848847536d0cdf'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIcDoubleCheckupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcDoubleCheckupResponseBody(name='body'),
}

async function getOcIcDoubleCheckupWithOptions(request: GetOcIcDoubleCheckupRequest, runtime: Util.RuntimeOptions): GetOcIcDoubleCheckupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcDoubleCheckup',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcDoubleCheckup(request: GetOcIcDoubleCheckupRequest): GetOcIcDoubleCheckupResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcDoubleCheckupWithOptions(request, runtime);
}

model GetOcIcEmployeeRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='210e842416657190633852480d9147'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcEmployeeResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      jobTitle?: string(name='JobTitle'),
      name?: string(name='Name'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcIcEmployeeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcEmployeeResponseBody(name='body'),
}

async function getOcIcEmployeeWithOptions(request: GetOcIcEmployeeRequest, runtime: Util.RuntimeOptions): GetOcIcEmployeeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcEmployee',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcEmployee(request: GetOcIcEmployeeRequest): GetOcIcEmployeeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcEmployeeWithOptions(request, runtime);
}

model GetOcIcEquityFrozenRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcEquityFrozenResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      freezeAmount?: string(name='FreezeAmount'),
      freezeCardNum?: string(name='FreezeCardNum', example='913302827369845089'),
      freezeCardType?: string(name='FreezeCardType'),
      freezeCourt?: string(name='FreezeCourt'),
      freezeEndDate?: string(name='FreezeEndDate', example='2022-11-12'),
      freezeExecItem?: string(name='FreezeExecItem'),
      freezeExecPerson?: string(name='FreezeExecPerson'),
      freezeNoticeNum?: string(name='FreezeNoticeNum'),
      freezePublishDate?: string(name='FreezePublishDate', example='2021-10-11'),
      freezeStartDate?: string(name='FreezeStartDate', example='2019-11-13'),
      status?: string(name='Status'),
      unfreezeAdjustNum?: string(name='UnfreezeAdjustNum'),
      unfreezeCourt?: string(name='UnfreezeCourt'),
      unfreezeDate?: string(name='UnfreezeDate'),
      unfreezeReason?: string(name='UnfreezeReason'),
    }
  ](name='Data'),
  message?: string(name='Message', example='keyword is empty'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88b016639000841033945dc0a3'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='111'),
}

model GetOcIcEquityFrozenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcEquityFrozenResponseBody(name='body'),
}

async function getOcIcEquityFrozenWithOptions(request: GetOcIcEquityFrozenRequest, runtime: Util.RuntimeOptions): GetOcIcEquityFrozenResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcEquityFrozen',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcEquityFrozen(request: GetOcIcEquityFrozenRequest): GetOcIcEquityFrozenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcEquityFrozenWithOptions(request, runtime);
}

model GetOcIcEquityPledgeRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcEquityPledgeResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      number?: string(name='Number', example='110108017579881_0002'),
      pawnee?: string(name='Pawnee'),
      pawneeIdentifyNo?: string(name='PawneeIdentifyNo', example='91440300746612636Q'),
      pledgor?: string(name='Pledgor'),
      pledgorAmount?: string(name='PledgorAmount', example='27.78'),
      pledgorIdentifyNo?: string(name='PledgorIdentifyNo', example='91310104087946746N'),
      publicDate?: string(name='PublicDate', example='2015-01-14'),
      regDate?: string(name='RegDate', example='2018-11-20'),
      relatedComp?: string(name='RelatedComp'),
      status?: string(name='Status'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e87ed16659791084703858dba39'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2468'),
}

model GetOcIcEquityPledgeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcEquityPledgeResponseBody(name='body'),
}

async function getOcIcEquityPledgeWithOptions(request: GetOcIcEquityPledgeRequest, runtime: Util.RuntimeOptions): GetOcIcEquityPledgeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcEquityPledge',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcEquityPledge(request: GetOcIcEquityPledgeRequest): GetOcIcEquityPledgeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcEquityPledgeWithOptions(request, runtime);
}

model GetOcIcInvestmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcInvestmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      investCreditCode?: string(name='InvestCreditCode', example='915203285993854016'),
      investEsDate?: string(name='InvestEsDate', example='2012-07-01'),
      investLegalName?: string(name='InvestLegalName'),
      investLicenseNo?: string(name='InvestLicenseNo', example='520328000148889'),
      investName?: string(name='InvestName'),
      investRegCap?: string(name='InvestRegCap'),
      investStatus?: string(name='InvestStatus'),
      shouldCap?: string(name='ShouldCap'),
      stockPercentage?: string(name='StockPercentage', example='49.0%'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88b016639000336733978dc0a3'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='4'),
}

model GetOcIcInvestmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcInvestmentResponseBody(name='body'),
}

async function getOcIcInvestmentWithOptions(request: GetOcIcInvestmentRequest, runtime: Util.RuntimeOptions): GetOcIcInvestmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcInvestment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcInvestment(request: GetOcIcInvestmentRequest): GetOcIcInvestmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcInvestmentWithOptions(request, runtime);
}

model GetOcIcKnowledgePropertyPledgeRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='210f078f16659784453422252dcdbb'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcKnowledgePropertyPledgeResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      name?: string(name='Name'),
      number?: string(name='Number', example='13311865'),
      pawnee?: string(name='Pawnee'),
      period?: string(name='Period'),
      pledgor?: string(name='Pledgor'),
      publicDate?: string(name='PublicDate', example='2016-06-02'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994514582084d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='40'),
}

model GetOcIcKnowledgePropertyPledgeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcKnowledgePropertyPledgeResponseBody(name='body'),
}

async function getOcIcKnowledgePropertyPledgeWithOptions(request: GetOcIcKnowledgePropertyPledgeRequest, runtime: Util.RuntimeOptions): GetOcIcKnowledgePropertyPledgeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcKnowledgePropertyPledge',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcKnowledgePropertyPledge(request: GetOcIcKnowledgePropertyPledgeRequest): GetOcIcKnowledgePropertyPledgeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcKnowledgePropertyPledgeWithOptions(request, runtime);
}

model GetOcIcMortgageRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcMortgageResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      debitAmount?: string(name='DebitAmount'),
      debitPeriod?: string(name='DebitPeriod'),
      debitScope?: string(name='DebitScope'),
      debitType?: string(name='DebitType'),
      department?: string(name='Department'),
      guarantees?: string(name='Guarantees'),
      identifyNo?: string(name='IdentifyNo', example='911301007302786537'),
      identifyType?: string(name='IdentifyType'),
      mortgageesName?: string(name='MortgageesName'),
      number?: string(name='Number', example='11012019000986'),
      onecompId?: string(name='OnecompId', description='ocid', example='1180716024506545226'),
      publicDate?: string(name='PublicDate', example='2016-06-02'),
      regDate?: string(name='RegDate', example='2018-11-20'),
      status?: string(name='Status'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16632257131545979d8a79'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2468'),
}

model GetOcIcMortgageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcMortgageResponseBody(name='body'),
}

async function getOcIcMortgageWithOptions(request: GetOcIcMortgageRequest, runtime: Util.RuntimeOptions): GetOcIcMortgageResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcMortgage',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcMortgage(request: GetOcIcMortgageRequest): GetOcIcMortgageResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcMortgageWithOptions(request, runtime);
}

model GetOcIcSeriousOffenseRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcSeriousOffenseResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      inDate?: string(name='InDate', example='2017-11-02'),
      inDepartment?: string(name='InDepartment'),
      inReason?: string(name='InReason'),
      outDate?: string(name='OutDate', example='2018-08-15'),
      outDepartment?: string(name='OutDepartment'),
      outReason?: string(name='OutReason'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e842416657190981275317d9147'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1514'),
}

model GetOcIcSeriousOffenseResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcSeriousOffenseResponseBody(name='body'),
}

async function getOcIcSeriousOffenseWithOptions(request: GetOcIcSeriousOffenseRequest, runtime: Util.RuntimeOptions): GetOcIcSeriousOffenseResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcSeriousOffense',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcSeriousOffense(request: GetOcIcSeriousOffenseRequest): GetOcIcSeriousOffenseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcSeriousOffenseWithOptions(request, runtime);
}

model GetOcIcShareholderRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcShareholderResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      shouldCap?: string(name='ShouldCap', example='90'),
      shouldCapTime?: string(name='ShouldCapTime', example='2025-01-29'),
      stockName?: string(name='StockName'),
      stockPercent?: string(name='StockPercent', example='90.00%'),
      stockType?: string(name='StockType'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e87ed16659790825224546dba39'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcIcShareholderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcShareholderResponseBody(name='body'),
}

async function getOcIcShareholderWithOptions(request: GetOcIcShareholderRequest, runtime: Util.RuntimeOptions): GetOcIcShareholderResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcShareholder',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcShareholder(request: GetOcIcShareholderRequest): GetOcIcShareholderResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcShareholderWithOptions(request, runtime);
}

model GetOcIcSimpleCancelRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIcSimpleCancelResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      entName?: string(name='EntName'),
      noticePeriod?: string(name='NoticePeriod'),
      scaContent?: string(name='ScaContent'),
      scaDate?: string(name='ScaDate', example='2022-08-22'),
      scaProposer?: string(name='ScaProposer'),
      scaResult?: string(name='ScaResult'),
      scaResultDate?: string(name='ScaResultDate', example='2022-08-30'),
      socialCreditCode?: string(name='SocialCreditCode', example='911302026610804662'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e849c16639169757322283dcabe'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIcSimpleCancelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIcSimpleCancelResponseBody(name='body'),
}

async function getOcIcSimpleCancelWithOptions(request: GetOcIcSimpleCancelRequest, runtime: Util.RuntimeOptions): GetOcIcSimpleCancelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIcSimpleCancel',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIcSimpleCancel(request: GetOcIcSimpleCancelRequest): GetOcIcSimpleCancelResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIcSimpleCancelWithOptions(request, runtime);
}

model GetOcIpCertificateRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpCertificateResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      authorizeDate?: string(name='AuthorizeDate', example='2019-05-14'),
      authorizeDepartment?: string(name='AuthorizeDepartment'),
      certNum?: string(name='CertNum', example='JY11107112389646'),
      certScope?: string(name='CertScope'),
      certType?: string(name='CertType'),
      entName?: string(name='EntName'),
      province?: string(name='Province', example='“”'),
      pubDate?: string(name='PubDate', example='“”'),
      validEndDate?: string(name='ValidEndDate', example='2024-05-13'),
      validStartDate?: string(name='ValidStartDate', example='2019-05-14'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e843c16644202319613241d1f89'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcIpCertificateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpCertificateResponseBody(name='body'),
}

async function getOcIpCertificateWithOptions(request: GetOcIpCertificateRequest, runtime: Util.RuntimeOptions): GetOcIpCertificateResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpCertificate',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpCertificate(request: GetOcIpCertificateRequest): GetOcIpCertificateResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpCertificateWithOptions(request, runtime);
}

model GetOcIpDomainRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpDomainResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      checkDate?: string(name='CheckDate', example='2020-10-12'),
      domain?: string(name='Domain', example='chinanonwovens.com'),
      entName?: string(name='EntName'),
      homeUrl?: string(name='HomeUrl', example='www.chinanonwovens.com'),
      number?: string(name='Number'),
      siteName?: string(name='SiteName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e88aa16589931835648642dc0ff'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIpDomainResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpDomainResponseBody(name='body'),
}

async function getOcIpDomainWithOptions(request: GetOcIpDomainRequest, runtime: Util.RuntimeOptions): GetOcIpDomainResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpDomain',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpDomain(request: GetOcIpDomainRequest): GetOcIpDomainResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpDomainWithOptions(request, runtime);
}

model GetOcIpPatentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpPatentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      agency?: string(name='Agency', example='“”'),
      agent?: string(name='Agent', example='“”'),
      brief?: string(name='Brief'),
      cateNum?: string(name='CateNum', example='6(2006.01)I'),
      entName?: string(name='EntName'),
      inventorList?: string(name='InventorList'),
      mainClaim?: string(name='MainClaim', example='“”'),
      patentName?: string(name='PatentName'),
      patentStatus?: string(name='PatentStatus'),
      patentType?: string(name='PatentType'),
      patenteeList?: string(name='PatenteeList'),
      prioDate?: string(name='PrioDate', example='“”'),
      prioNum?: string(name='PrioNum', example='“”'),
      publicDate?: string(name='PublicDate', example='2020-09-22'),
      publicNum?: string(name='PublicNum', example='CN111684990A'),
      requestDate?: string(name='RequestDate', example='2019-03-13'),
      requestNum?: string(name='RequestNum', example='CN201910186714.9'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e847116626051242854054d8b16'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIpPatentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpPatentResponseBody(name='body'),
}

async function getOcIpPatentWithOptions(request: GetOcIpPatentRequest, runtime: Util.RuntimeOptions): GetOcIpPatentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpPatent',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpPatent(request: GetOcIpPatentRequest): GetOcIpPatentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpPatentWithOptions(request, runtime);
}

model GetOcIpSoftwareCopyrightRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpSoftwareCopyrightResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      approvalDate?: string(name='ApprovalDate', example='2019-09-12'),
      copyName?: string(name='CopyName'),
      copyNum?: string(name='CopyNum', example='2019SR0950125'),
      entName?: string(name='EntName'),
      firstDate?: string(name='FirstDate', example='2019-02-15'),
      shortName?: string(name='ShortName', example='“”'),
      successDate?: string(name='SuccessDate', example='2019-02-15'),
      typeNum?: string(name='TypeNum', example='30200-0000'),
      version?: string(name='Version', example='V1.0'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcIpSoftwareCopyrightResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpSoftwareCopyrightResponseBody(name='body'),
}

async function getOcIpSoftwareCopyrightWithOptions(request: GetOcIpSoftwareCopyrightRequest, runtime: Util.RuntimeOptions): GetOcIpSoftwareCopyrightResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpSoftwareCopyright',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpSoftwareCopyright(request: GetOcIpSoftwareCopyrightRequest): GetOcIpSoftwareCopyrightResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpSoftwareCopyrightWithOptions(request, runtime);
}

model GetOcIpTrademarkRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpTrademarkResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      agent?: string(name='Agent'),
      applyDate?: string(name='ApplyDate', example='2005-04-30'),
      entName?: string(name='EntName'),
      firstPubDate?: string(name='FirstPubDate', example='2008-09-27'),
      firstPubNo?: string(name='FirstPubNo', example='1137'),
      imageUrl?: string(name='ImageUrl', example='https://qxb-img-osscache.qixin.com/official_trademark/af62332c79813d1283541b11a3da50da.jpg'),
      period?: string(name='Period'),
      regNum?: string(name='RegNum', example='4636939'),
      regPubDate?: string(name='RegPubDate', example='2008-12-28'),
      regPubNo?: string(name='RegPubNo', example='1149'),
      trademarkForm?: string(name='TrademarkForm'),
      trademarkName?: string(name='TrademarkName', example='CTTA'),
      trademarkStatus?: string(name='TrademarkStatus'),
      trademarkType?: string(name='TrademarkType'),
      typeName?: string(name='TypeName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e843c16644202319613241d1f89'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIpTrademarkResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpTrademarkResponseBody(name='body'),
}

async function getOcIpTrademarkWithOptions(request: GetOcIpTrademarkRequest, runtime: Util.RuntimeOptions): GetOcIpTrademarkResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpTrademark',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpTrademark(request: GetOcIpTrademarkRequest): GetOcIpTrademarkResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpTrademarkWithOptions(request, runtime);
}

model GetOcIpWorksCopyrightRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcIpWorksCopyrightResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      approvalDate?: string(name='ApprovalDate', example='2017-07-19'),
      copyName?: string(name='CopyName'),
      copyNum?: string(name='CopyNum'),
      entName?: string(name='EntName'),
      firstDate?: string(name='FirstDate', example='2017-01-03'),
      successDate?: string(name='SuccessDate', example='2016-09-13'),
      typeName?: string(name='TypeName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f078f16659784453422252dcdbb'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcIpWorksCopyrightResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcIpWorksCopyrightResponseBody(name='body'),
}

async function getOcIpWorksCopyrightWithOptions(request: GetOcIpWorksCopyrightRequest, runtime: Util.RuntimeOptions): GetOcIpWorksCopyrightResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcIpWorksCopyright',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcIpWorksCopyright(request: GetOcIpWorksCopyrightRequest): GetOcIpWorksCopyrightResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcIpWorksCopyrightWithOptions(request, runtime);
}

model GetOcJusticeAuctionRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeAuctionResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      auctionDate?: string(name='AuctionDate'),
      auctionName?: string(name='AuctionName'),
      basis?: string(name='Basis'),
      certificate?: string(name='Certificate'),
      court?: string(name='Court'),
      description?: string(name='Description'),
      document?: string(name='Document'),
      entName?: string(name='EntName'),
      estPrice?: string(name='EstPrice'),
      owner?: string(name='Owner'),
      restrict?: string(name='Restrict'),
      startPrice?: string(name='StartPrice'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07bc16659785110232611d506e'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='40'),
}

model GetOcJusticeAuctionResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeAuctionResponseBody(name='body'),
}

async function getOcJusticeAuctionWithOptions(request: GetOcJusticeAuctionRequest, runtime: Util.RuntimeOptions): GetOcJusticeAuctionResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeAuction',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeAuction(request: GetOcJusticeAuctionRequest): GetOcJusticeAuctionResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeAuctionWithOptions(request, runtime);
}

model GetOcJusticeCaseFilingRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeCaseFilingResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      assistant?: string(name='Assistant'),
      caseNum?: string(name='CaseNum'),
      caseStatus?: string(name='CaseStatus'),
      causeAction?: string(name='CauseAction'),
      endDate?: string(name='EndDate', example='2022-01-07'),
      filingDate?: string(name='FilingDate', example='2013-02-16'),
      hearingDate?: string(name='HearingDate'),
      judge?: string(name='Judge'),
      party?: string(name='Party'),
      role?: string(name='Role'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994177416146d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2461'),
}

model GetOcJusticeCaseFilingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeCaseFilingResponseBody(name='body'),
}

async function getOcJusticeCaseFilingWithOptions(request: GetOcJusticeCaseFilingRequest, runtime: Util.RuntimeOptions): GetOcJusticeCaseFilingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeCaseFiling',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeCaseFiling(request: GetOcJusticeCaseFilingRequest): GetOcJusticeCaseFilingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeCaseFilingWithOptions(request, runtime);
}

model GetOcJusticeCourtAnnouncementRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeCourtAnnouncementResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      caseNum?: string(name='CaseNum'),
      causeAction?: string(name='CauseAction'),
      court?: string(name='Court'),
      department?: string(name='Department'),
      hearingDate?: string(name='HearingDate', example='2021-07-14 11:11:00'),
      judge?: string(name='Judge'),
      party?: string(name='Party'),
      title?: string(name='Title'),
      tribunal?: string(name='Tribunal'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e842416657191086991309d9147'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1514'),
}

model GetOcJusticeCourtAnnouncementResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeCourtAnnouncementResponseBody(name='body'),
}

async function getOcJusticeCourtAnnouncementWithOptions(request: GetOcJusticeCourtAnnouncementRequest, runtime: Util.RuntimeOptions): GetOcJusticeCourtAnnouncementResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeCourtAnnouncement',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeCourtAnnouncement(request: GetOcJusticeCourtAnnouncementRequest): GetOcJusticeCourtAnnouncementResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeCourtAnnouncementWithOptions(request, runtime);
}

model GetOcJusticeCourtNoticeRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='210e843416644201952421098d665b'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeCourtNoticeResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      content?: string(name='Content'),
      court?: string(name='Court'),
      party?: string(name='Party'),
      publicDate?: string(name='PublicDate', example='2021-04-25'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e843416644201952421098d665b'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcJusticeCourtNoticeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeCourtNoticeResponseBody(name='body'),
}

async function getOcJusticeCourtNoticeWithOptions(request: GetOcJusticeCourtNoticeRequest, runtime: Util.RuntimeOptions): GetOcJusticeCourtNoticeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeCourtNotice',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeCourtNotice(request: GetOcJusticeCourtNoticeRequest): GetOcJusticeCourtNoticeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeCourtNoticeWithOptions(request, runtime);
}

model GetOcJusticeDishonestyRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeDishonestyResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      amount?: string(name='Amount', example='160000.0'),
      caseNum?: string(name='CaseNum'),
      court?: string(name='Court'),
      entName?: string(name='EntName'),
      executeDepartment?: string(name='ExecuteDepartment'),
      executionDesc?: string(name='ExecutionDesc'),
      executionStatus?: string(name='ExecutionStatus'),
      filingDate?: string(name='FilingDate', example='2015-08-03'),
      finalDuty?: string(name='FinalDuty'),
      fromCaseNum?: string(name='FromCaseNum'),
      legalName?: string(name='LegalName'),
      province?: string(name='Province'),
      publishDate?: string(name='PublishDate', example='2015-11-11'),
      socialCreditCode?: string(name='SocialCreditCode', example='914403006700460677'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07d816659791482017228dbf2c'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='28'),
}

model GetOcJusticeDishonestyResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeDishonestyResponseBody(name='body'),
}

async function getOcJusticeDishonestyWithOptions(request: GetOcJusticeDishonestyRequest, runtime: Util.RuntimeOptions): GetOcJusticeDishonestyResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeDishonesty',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeDishonesty(request: GetOcJusticeDishonestyRequest): GetOcJusticeDishonestyResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeDishonestyWithOptions(request, runtime);
}

model GetOcJusticeExecutedRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='210f07bc16659785171694435d506e'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeExecutedResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      amount?: string(name='Amount', example='1387500.0'),
      caseNum?: string(name='CaseNum'),
      court?: string(name='Court'),
      filingDate?: string(name='FilingDate', example='2022-09-21'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e849816657191257693178da7ea'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='5'),
}

model GetOcJusticeExecutedResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeExecutedResponseBody(name='body'),
}

async function getOcJusticeExecutedWithOptions(request: GetOcJusticeExecutedRequest, runtime: Util.RuntimeOptions): GetOcJusticeExecutedResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeExecuted',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeExecuted(request: GetOcJusticeExecutedRequest): GetOcJusticeExecutedResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeExecutedWithOptions(request, runtime);
}

model GetOcJusticeJudgementDocRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeJudgementDocResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      caseFlow?: string(name='CaseFlow'),
      caseNum?: string(name='CaseNum'),
      caseType?: string(name='CaseType'),
      causeAction?: string(name='CauseAction'),
      court?: string(name='Court'),
      defendant?: string(name='Defendant', example='-'),
      judgeDate?: string(name='JudgeDate', example='2022-01-29'),
      judgeResult?: string(name='JudgeResult'),
      judgeType?: string(name='JudgeType', example='-'),
      party?: string(name='Party'),
      plaintiff?: string(name='Plaintiff', example='-'),
      publicDate?: string(name='PublicDate', example='2016-06-02'),
      role?: string(name='Role'),
      subAmount?: string(name='SubAmount', example='-'),
      title?: string(name='Title'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e843416644201828875969d665b'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='10'),
}

model GetOcJusticeJudgementDocResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeJudgementDocResponseBody(name='body'),
}

async function getOcJusticeJudgementDocWithOptions(request: GetOcJusticeJudgementDocRequest, runtime: Util.RuntimeOptions): GetOcJusticeJudgementDocResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeJudgementDoc',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeJudgementDoc(request: GetOcJusticeJudgementDocRequest): GetOcJusticeJudgementDocResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeJudgementDocWithOptions(request, runtime);
}

model GetOcJusticeLimitHighConsumeRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='210e843316661640469071015dbd28'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeLimitHighConsumeResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      caseNum?: string(name='CaseNum'),
      causeAction?: string(name='CauseAction'),
      companyName?: string(name='CompanyName'),
      court?: string(name='Court'),
      executionApplicant?: string(name='ExecutionApplicant'),
      filingDate?: string(name='FilingDate', example='2022-06-14'),
      name?: string(name='Name'),
      publishDate?: string(name='PublishDate', example='2022-10-27'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994120204184d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='135'),
}

model GetOcJusticeLimitHighConsumeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeLimitHighConsumeResponseBody(name='body'),
}

async function getOcJusticeLimitHighConsumeWithOptions(request: GetOcJusticeLimitHighConsumeRequest, runtime: Util.RuntimeOptions): GetOcJusticeLimitHighConsumeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeLimitHighConsume',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeLimitHighConsume(request: GetOcJusticeLimitHighConsumeRequest): GetOcJusticeLimitHighConsumeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeLimitHighConsumeWithOptions(request, runtime);
}

model GetOcJusticeTerminalCaseRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcJusticeTerminalCaseResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      caseNum?: string(name='CaseNum'),
      court?: string(name='Court'),
      entName?: string(name='EntName'),
      execAmount?: string(name='ExecAmount', example='2141166.0'),
      failPerformAmount?: string(name='FailPerformAmount', example='2141166.0'),
      filingDate?: string(name='FilingDate', example='2022-03-05'),
      name?: string(name='Name'),
      terminalNum?: string(name='TerminalNum'),
      terminateDate?: string(name='TerminateDate', example='2022-07-27'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e849816657191320625369da7ea'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='161'),
}

model GetOcJusticeTerminalCaseResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcJusticeTerminalCaseResponseBody(name='body'),
}

async function getOcJusticeTerminalCaseWithOptions(request: GetOcJusticeTerminalCaseRequest, runtime: Util.RuntimeOptions): GetOcJusticeTerminalCaseResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcJusticeTerminalCase',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcJusticeTerminalCase(request: GetOcJusticeTerminalCaseRequest): GetOcJusticeTerminalCaseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcJusticeTerminalCaseWithOptions(request, runtime);
}

model GetOcListedCompanyRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcListedCompanyResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      circulationMarketValue?: string(name='CirculationMarketValue', example='140.68'),
      entName?: string(name='EntName'),
      entNameEng?: string(name='EntNameEng', example='Chengdu CORPRO Technology Co.,Ltd.'),
      listDate?: string(name='ListDate', example='2010-08-06'),
      securitiesCode?: string(name='SecuritiesCode', example='300101'),
      securitiesMarket?: string(name='SecuritiesMarket'),
      securitiesName?: string(name='SecuritiesName'),
      totalFlowShares?: string(name='TotalFlowShares', example='55721'),
      totalShares?: string(name='TotalShares', example='56007'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e848716425594711335674da0a1'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcListedCompanyResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcListedCompanyResponseBody(name='body'),
}

async function getOcListedCompanyWithOptions(request: GetOcListedCompanyRequest, runtime: Util.RuntimeOptions): GetOcListedCompanyResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcListedCompany',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcListedCompany(request: GetOcListedCompanyRequest): GetOcListedCompanyResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcListedCompanyWithOptions(request, runtime);
}

model GetOcNegativeAdminPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcNegativeAdminPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      entName?: string(name='EntName'),
      illegalType?: string(name='IllegalType'),
      lawBasis?: string(name='LawBasis'),
      publicDate?: string(name='PublicDate', example='2016-01-15'),
      punishDate?: string(name='PunishDate', example='2016-01-15'),
      punishNum?: string(name='PunishNum'),
      punishResult?: string(name='PunishResult'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07ff16403976324112713d273d'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='13'),
}

model GetOcNegativeAdminPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcNegativeAdminPunishmentResponseBody(name='body'),
}

async function getOcNegativeAdminPunishmentWithOptions(request: GetOcNegativeAdminPunishmentRequest, runtime: Util.RuntimeOptions): GetOcNegativeAdminPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcNegativeAdminPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcNegativeAdminPunishment(request: GetOcNegativeAdminPunishmentRequest): GetOcNegativeAdminPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcNegativeAdminPunishmentWithOptions(request, runtime);
}

model GetOcNegativeCustomsPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcNegativeCustomsPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      basis?: string(name='Basis', example='""'),
      caseNo?: string(name='CaseNo', example='""'),
      customs?: string(name='Customs', example='""'),
      customsNo?: string(name='CustomsNo', example='""'),
      legalName?: string(name='LegalName', example='""'),
      punishDate?: string(name='PunishDate'),
      punishType?: string(name='PunishType', example='""'),
      title?: string(name='Title'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994514582084d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcNegativeCustomsPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcNegativeCustomsPunishmentResponseBody(name='body'),
}

async function getOcNegativeCustomsPunishmentWithOptions(request: GetOcNegativeCustomsPunishmentRequest, runtime: Util.RuntimeOptions): GetOcNegativeCustomsPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcNegativeCustomsPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcNegativeCustomsPunishment(request: GetOcNegativeCustomsPunishmentRequest): GetOcNegativeCustomsPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcNegativeCustomsPunishmentWithOptions(request, runtime);
}

model GetOcNegativeEnvironmentPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcNegativeEnvironmentPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      entName?: string(name='EntName'),
      execStatus?: string(name='ExecStatus'),
      punishBasis?: string(name='PunishBasis'),
      punishContent?: string(name='PunishContent'),
      punishDate?: string(name='PunishDate', example='2017-08-11'),
      punishLaw?: string(name='PunishLaw'),
      punishNum?: string(name='PunishNum'),
      punishRes?: string(name='PunishRes'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f078f16659784453422252dcdbb'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='10'),
}

model GetOcNegativeEnvironmentPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcNegativeEnvironmentPunishmentResponseBody(name='body'),
}

async function getOcNegativeEnvironmentPunishmentWithOptions(request: GetOcNegativeEnvironmentPunishmentRequest, runtime: Util.RuntimeOptions): GetOcNegativeEnvironmentPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcNegativeEnvironmentPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcNegativeEnvironmentPunishment(request: GetOcNegativeEnvironmentPunishmentRequest): GetOcNegativeEnvironmentPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcNegativeEnvironmentPunishmentWithOptions(request, runtime);
}

model GetOcNegativeFoodDrugPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcNegativeFoodDrugPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      entName?: string(name='EntName'),
      illegalType?: string(name='IllegalType'),
      lawBasis?: string(name='LawBasis'),
      publicDate?: string(name='PublicDate', example='2017-04-26'),
      punishDate?: string(name='PunishDate', example='2017-04-26'),
      punishNum?: string(name='PunishNum'),
      punishResult?: string(name='PunishResult'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f44c216557954247657883d1827'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcNegativeFoodDrugPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcNegativeFoodDrugPunishmentResponseBody(name='body'),
}

async function getOcNegativeFoodDrugPunishmentWithOptions(request: GetOcNegativeFoodDrugPunishmentRequest, runtime: Util.RuntimeOptions): GetOcNegativeFoodDrugPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcNegativeFoodDrugPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcNegativeFoodDrugPunishment(request: GetOcNegativeFoodDrugPunishmentRequest): GetOcNegativeFoodDrugPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcNegativeFoodDrugPunishmentWithOptions(request, runtime);
}

model GetOcNegativeQualityPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcNegativeQualityPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department', example='-'),
      entName?: string(name='EntName'),
      eventDate?: string(name='EventDate', example='-'),
      eventResult?: string(name='EventResult', example='-'),
      pubDate?: string(name='PubDate', example='-'),
      title?: string(name='Title'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e843416644200898391578d665b'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcNegativeQualityPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcNegativeQualityPunishmentResponseBody(name='body'),
}

async function getOcNegativeQualityPunishmentWithOptions(request: GetOcNegativeQualityPunishmentRequest, runtime: Util.RuntimeOptions): GetOcNegativeQualityPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcNegativeQualityPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcNegativeQualityPunishment(request: GetOcNegativeQualityPunishmentRequest): GetOcNegativeQualityPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcNegativeQualityPunishmentWithOptions(request, runtime);
}

model GetOcOperationBiddingRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcOperationBiddingResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      agentEntName?: string(name='AgentEntName'),
      bidIndustry?: string(name='BidIndustry'),
      bidTitle?: string(name='BidTitle'),
      bidType?: string(name='BidType'),
      content?: string(name='Content'),
      entName?: string(name='EntName'),
      infoType?: string(name='InfoType'),
      openingTime?: string(name='OpeningTime', example='“”'),
      projectAmount?: string(name='ProjectAmount', example='“”'),
      projectName?: string(name='ProjectName', example='“”'),
      projectNum?: string(name='ProjectNum', example='91130983MA08JE8318\\t91130983398899748J\\t91130983MA08GQLM67'),
      publicDate?: string(name='PublicDate', example='2021-05-19'),
      regionName?: string(name='RegionName'),
      subType?: string(name='SubType'),
      tenderEntName?: string(name='TenderEntName'),
      winnerEntName?: string(name='WinnerEntName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e842416657191086991309d9147'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcOperationBiddingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcOperationBiddingResponseBody(name='body'),
}

async function getOcOperationBiddingWithOptions(request: GetOcOperationBiddingRequest, runtime: Util.RuntimeOptions): GetOcOperationBiddingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcOperationBidding',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcOperationBidding(request: GetOcOperationBiddingRequest): GetOcOperationBiddingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcOperationBiddingWithOptions(request, runtime);
}

model GetOcOperationCustomsRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcOperationCustomsResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      adminRegionName?: string(name='AdminRegionName'),
      annualReport?: string(name='AnnualReport'),
      businessCate?: string(name='BusinessCate'),
      cancelFlag?: string(name='CancelFlag'),
      creditLevelsNew?: string(name='CreditLevelsNew'),
      customsNum?: string(name='CustomsNum', example='4422960996'),
      customsReg?: string(name='CustomsReg'),
      ecoRegionName?: string(name='EcoRegionName'),
      electType?: string(name='ElectType', example='“”'),
      entName?: string(name='EntName'),
      identCode?: string(name='IdentCode', example='“”'),
      identDate?: string(name='IdentDate', example='2008-03-26'),
      industryType?: string(name='IndustryType'),
      regDate?: string(name='RegDate', example='2008-03-26'),
      specialArea?: string(name='SpecialArea'),
      validDate?: string(name='ValidDate', example='2015-07-31'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876a16661631626916171d4d19'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcOperationCustomsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcOperationCustomsResponseBody(name='body'),
}

async function getOcOperationCustomsWithOptions(request: GetOcOperationCustomsRequest, runtime: Util.RuntimeOptions): GetOcOperationCustomsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcOperationCustoms',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcOperationCustoms(request: GetOcOperationCustomsRequest): GetOcOperationCustomsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcOperationCustomsWithOptions(request, runtime);
}

model GetOcOperationPurchaseLandRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcOperationPurchaseLandResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      area?: string(name='Area', example='1.0148'),
      department?: string(name='Department'),
      electronicNo?: string(name='ElectronicNo', example='3708322017B00230'),
      entName?: string(name='EntName'),
      industry?: string(name='Industry'),
      landLevel?: string(name='LandLevel'),
      landSource?: string(name='LandSource'),
      landUse?: string(name='LandUse'),
      location?: string(name='Location'),
      price?: string(name='Price', example='1964.0'),
      projectName?: string(name='ProjectName'),
      promiseDeliveryDate?: string(name='PromiseDeliveryDate', example='2017-04-26'),
      promiseEndDate?: string(name='PromiseEndDate', example='2020-10-11'),
      promiseStartDate?: string(name='PromiseStartDate', example='2017-10-11'),
      regionName?: string(name='RegionName'),
      releaseDate?: string(name='ReleaseDate', example='2017-04-11'),
      signingMode?: string(name='SigningMode'),
      useYear?: string(name='UseYear'),
      volumeFractionLowerBound?: string(name='VolumeFractionLowerBound', example='2.5'),
      volumeFractionUpperBound?: string(name='VolumeFractionUpperBound', example='2.87'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='1'),
}

model GetOcOperationPurchaseLandResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcOperationPurchaseLandResponseBody(name='body'),
}

async function getOcOperationPurchaseLandWithOptions(request: GetOcOperationPurchaseLandRequest, runtime: Util.RuntimeOptions): GetOcOperationPurchaseLandResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcOperationPurchaseLand',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcOperationPurchaseLand(request: GetOcOperationPurchaseLandRequest): GetOcOperationPurchaseLandResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcOperationPurchaseLandWithOptions(request, runtime);
}

model GetOcOperationRecruitmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcOperationRecruitmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      benefitList?: string(name='BenefitList'),
      description?: string(name='Description'),
      education?: string(name='Education'),
      endDate?: string(name='EndDate', example='2019-03-12'),
      entName?: string(name='EntName'),
      experience?: string(name='Experience'),
      pageUrl?: string(name='PageUrl', example='https://jobs.zhaopin.com/CZ446399310J00101222109.htm'),
      publishDate?: string(name='PublishDate', example='2019-02-12'),
      recruitingAddress?: string(name='RecruitingAddress'),
      recruitingName?: string(name='RecruitingName'),
      salary?: string(name='Salary', example='3500.0-7000.0'),
      startDate?: string(name='StartDate', example='2019-02-12'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e846e16638994402826438d27a7'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcOperationRecruitmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcOperationRecruitmentResponseBody(name='body'),
}

async function getOcOperationRecruitmentWithOptions(request: GetOcOperationRecruitmentRequest, runtime: Util.RuntimeOptions): GetOcOperationRecruitmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcOperationRecruitment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcOperationRecruitment(request: GetOcOperationRecruitmentRequest): GetOcOperationRecruitmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcOperationRecruitmentWithOptions(request, runtime);
}

model GetOcProductBandRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcProductBandResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      brandIntroduction?: string(name='BrandIntroduction'),
      device?: string(name='Device', example='android,ios'),
      entName?: string(name='EntName'),
      productIntroduction?: string(name='ProductIntroduction'),
      productLogo?: string(name='ProductLogo', example='http://oss.cyzone.cn/2016/1028/20161028040354529.png'),
      productName?: string(name='ProductName'),
      productTag?: string(name='ProductTag'),
      productWebsite?: string(name='ProductWebsite', example='http://bluevr.cn'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='2'),
}

model GetOcProductBandResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcProductBandResponseBody(name='body'),
}

async function getOcProductBandWithOptions(request: GetOcProductBandRequest, runtime: Util.RuntimeOptions): GetOcProductBandResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcProductBand',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcProductBand(request: GetOcProductBandRequest): GetOcProductBandResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcProductBandWithOptions(request, runtime);
}

model GetOcTaxAbnormalRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxAbnormalResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      cardNum?: string(name='CardNum', example='120102******142'),
      cardType?: string(name='CardType'),
      entName?: string(name='EntName'),
      judgeDate?: string(name='JudgeDate', example='2019-11-18'),
      judgeDepartment?: string(name='JudgeDepartment'),
      judgeReason?: string(name='JudgeReason'),
      legalName?: string(name='LegalName'),
      overdueAmount?: string(name='OverdueAmount', example='45034.56'),
      overdueType?: string(name='OverdueType', example='-'),
      status?: string(name='Status'),
      taxpayerNum?: string(name='TaxpayerNum', example='110222802498998'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07c316396500746015095d3afb'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='10'),
}

model GetOcTaxAbnormalResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxAbnormalResponseBody(name='body'),
}

async function getOcTaxAbnormalWithOptions(request: GetOcTaxAbnormalRequest, runtime: Util.RuntimeOptions): GetOcTaxAbnormalResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxAbnormal',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxAbnormal(request: GetOcTaxAbnormalRequest): GetOcTaxAbnormalResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxAbnormalWithOptions(request, runtime);
}

model GetOcTaxClassARequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxClassAResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      entName?: string(name='EntName'),
      taxLevel?: string(name='TaxLevel', example='A'),
      taxpayerNum?: string(name='TaxpayerNum', example='911101073272861276'),
      year?: string(name='Year', example='2018'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e842416657191086991309d9147'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='28'),
}

model GetOcTaxClassAResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxClassAResponseBody(name='body'),
}

async function getOcTaxClassAWithOptions(request: GetOcTaxClassARequest, runtime: Util.RuntimeOptions): GetOcTaxClassAResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxClassA',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxClassA(request: GetOcTaxClassARequest): GetOcTaxClassAResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxClassAWithOptions(request, runtime);
}

model GetOcTaxGeneralTaxpayerRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxGeneralTaxpayerResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      endDate?: string(name='EndDate', example='2022-08-08'),
      entName?: string(name='EntName'),
      judgeDate?: string(name='JudgeDate', example='1999-01-01'),
      qualification?: string(name='Qualification'),
      startDate?: string(name='StartDate', example='2021-06-11'),
      taxpayerNum?: string(name='TaxpayerNum', example='91120110328591094E'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210e876f16684793977147683dc6e6'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='40'),
}

model GetOcTaxGeneralTaxpayerResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxGeneralTaxpayerResponseBody(name='body'),
}

async function getOcTaxGeneralTaxpayerWithOptions(request: GetOcTaxGeneralTaxpayerRequest, runtime: Util.RuntimeOptions): GetOcTaxGeneralTaxpayerResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxGeneralTaxpayer',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxGeneralTaxpayer(request: GetOcTaxGeneralTaxpayerRequest): GetOcTaxGeneralTaxpayerResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxGeneralTaxpayerWithOptions(request, runtime);
}

model GetOcTaxIllegalRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxIllegalResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      agencyCardNum?: string(name='AgencyCardNum', example='140424********2022'),
      agencyCardType?: string(name='AgencyCardType'),
      agencyEnt?: string(name='AgencyEnt'),
      agencyName?: string(name='AgencyName'),
      agencySex?: string(name='AgencySex'),
      caseType?: string(name='CaseType'),
      department?: string(name='Department'),
      entAddress?: string(name='EntAddress'),
      entName?: string(name='EntName'),
      financialCardNum?: string(name='FinancialCardNum', example='140424********2014'),
      financialCardType?: string(name='FinancialCardType'),
      financialName?: string(name='FinancialName'),
      financialSex?: string(name='FinancialSex'),
      illegalTruth?: string(name='IllegalTruth'),
      lawBasis?: string(name='LawBasis'),
      legalCardNum?: string(name='LegalCardNum', example='410527********4211'),
      legalCardType?: string(name='LegalCardType'),
      legalName?: string(name='LegalName'),
      legalSex?: string(name='LegalSex'),
      orgCode?: string(name='OrgCode', example='MA28T91P1'),
      publishDate?: string(name='PublishDate', example='2020-03-04'),
      taxpayerNum?: string(name='TaxpayerNum', example='91330104MA28T91P12'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07d816659791482017228dbf2c'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='135'),
}

model GetOcTaxIllegalResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxIllegalResponseBody(name='body'),
}

async function getOcTaxIllegalWithOptions(request: GetOcTaxIllegalRequest, runtime: Util.RuntimeOptions): GetOcTaxIllegalResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxIllegal',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxIllegal(request: GetOcTaxIllegalRequest): GetOcTaxIllegalResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxIllegalWithOptions(request, runtime);
}

model GetOcTaxOverdueRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxOverdueResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      currOverdueAmount?: string(name='CurrOverdueAmount', example='2434.56'),
      department?: string(name='Department'),
      entAddress?: string(name='EntAddress'),
      entName?: string(name='EntName'),
      legalName?: string(name='LegalName'),
      overdueAmount?: string(name='OverdueAmount', example='2434.56'),
      overdueType?: string(name='OverdueType'),
      publishDate?: string(name='PublishDate', example='2022-10-31'),
      taxpayerNum?: string(name='TaxpayerNum', example='91310117MA7DKB2J92'),
      taxpayerType?: string(name='TaxpayerType', example='-'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f44a216685643011392991dd6da'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='4'),
}

model GetOcTaxOverdueResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxOverdueResponseBody(name='body'),
}

async function getOcTaxOverdueWithOptions(request: GetOcTaxOverdueRequest, runtime: Util.RuntimeOptions): GetOcTaxOverdueResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxOverdue',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxOverdue(request: GetOcTaxOverdueRequest): GetOcTaxOverdueResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxOverdueWithOptions(request, runtime);
}

model GetOcTaxPunishmentRequest {
  pageNo?: int32(name='PageNo', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  searchKey?: string(name='SearchKey'),
}

model GetOcTaxPunishmentResponseBody = {
  code?: string(name='Code', example='000000'),
  data?: [ 
    {
      department?: string(name='Department'),
      entName?: string(name='EntName'),
      eventName?: string(name='EventName', example='-'),
      eventType?: string(name='EventType', example='-'),
      legalName?: string(name='LegalName'),
      punishDate?: string(name='PunishDate', example='2011-10-01'),
      taxpayerNum?: string(name='TaxpayerNum', example='91310117MA7DKB2J92'),
      title?: string(name='Title'),
    }
  ](name='Data'),
  message?: string(name='Message', example='success'),
  pageIndex?: int32(name='PageIndex', example='1'),
  pageNum?: int32(name='PageNum', example='10'),
  requestId?: string(name='RequestId', example='210f07ee16394533371005776dbb6e'),
  success?: boolean(name='Success', example='True'),
  totalNum?: int32(name='TotalNum', example='13'),
}

model GetOcTaxPunishmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOcTaxPunishmentResponseBody(name='body'),
}

async function getOcTaxPunishmentWithOptions(request: GetOcTaxPunishmentRequest, runtime: Util.RuntimeOptions): GetOcTaxPunishmentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    body['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOcTaxPunishment',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOcTaxPunishment(request: GetOcTaxPunishmentRequest): GetOcTaxPunishmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOcTaxPunishmentWithOptions(request, runtime);
}

model GetQccCertificationDetailByIdRequest {
  certId?: string(name='CertId'),
}

model GetQccCertificationDetailByIdResponseBody = {
  code?: string(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageIndex?: int32(name='PageIndex'),
  pageNum?: int32(name='PageNum'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalNum?: int32(name='TotalNum'),
}

model GetQccCertificationDetailByIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetQccCertificationDetailByIdResponseBody(name='body'),
}

async function getQccCertificationDetailByIdWithOptions(request: GetQccCertificationDetailByIdRequest, runtime: Util.RuntimeOptions): GetQccCertificationDetailByIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.certId)) {
    body['CertId'] = request.certId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetQccCertificationDetailById',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getQccCertificationDetailById(request: GetQccCertificationDetailByIdRequest): GetQccCertificationDetailByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQccCertificationDetailByIdWithOptions(request, runtime);
}

model GetQccSearchCertificationRequest {
  certCategory?: string(name='CertCategory'),
  entName?: string(name='EntName'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
}

model GetQccSearchCertificationResponseBody = {
  code?: string(name='Code'),
  data?: [ map[string]any ](name='Data'),
  message?: string(name='Message'),
  pageIndex?: int32(name='PageIndex'),
  pageNum?: int32(name='PageNum'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalNum?: int32(name='TotalNum'),
}

model GetQccSearchCertificationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetQccSearchCertificationResponseBody(name='body'),
}

async function getQccSearchCertificationWithOptions(request: GetQccSearchCertificationRequest, runtime: Util.RuntimeOptions): GetQccSearchCertificationResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.certCategory)) {
    body['CertCategory'] = request.certCategory;
  }
  if (!Util.isUnset(request.entName)) {
    body['EntName'] = request.entName;
  }
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetQccSearchCertification',
    version = '2022-08-29',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getQccSearchCertification(request: GetQccSearchCertificationRequest): GetQccSearchCertificationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQccSearchCertificationWithOptions(request, runtime);
}

